//“产品中心”——>“产品详情”

const moment=require('moment');
const mongoose=require('mongoose');
const url=require('url');
const proDetailModel=require('../models/proDetail.js');
const proCenterModel=require('../models/proCenter.js');


class ProDetailControllers{
    //一.后台
    //1.产品分类的curd

    //1.1展示
    static getProCenterList=async(req,res)=>{

        let {page=1,size=2}=req.query;
        page=parseInt(page);
        size=parseInt(size);
//获取总数
//         let count= await proCenterModel.count();
        let count= await proCenterModel.countDocuments();
        //Collection.countDocuments count方法已被弃用，改用countDocuments方法
//获取偏移量
        let offset=(page-1)*size;
//获取总共的页数
        let totalPage=Math.ceil(count/size);
        //得到新闻分类的内容
        const infos=await proCenterModel.aggregate([
            {
                $skip:offset
            },
            {
                $limit:size
            },
        ]);
        res.render('proCenter-list',{page,size,count,totalPage,title:'产品分类的展示',infos});
    };
    //1.2删除
    //
    static getProCenterDelete=async (req,res)=>{
        //req.json()会把格式化字符串的对象响应给浏览器，并可以把一个js对象转换为一个对象格式的字符串，方便查看。
        //得到新闻分类的内容
        // /res.json(req.params);
        let centerId=req.params.id;
        try{
            await proCenterModel.deleteOne({_id:centerId});
            //back返回上一级页面
            res.redirect('back');
        }catch (e) {
            //back返回上一级页面
            res.redirect('back');
        }
    };

    //1.3编辑
    //查找数据
    static getProCenterEdit=async (req,res)=>{
        //得到id
        let centerId=req.params.id;
        //通过id进行查找
        let info=await proCenterModel.findOne({_id:centerId});

        res.render('proCenter-edit',{title:'产品分类的编辑',info});


    };
    //更新至数据库
    static getProCenterEditStore=(req,res)=>{
        let {centername,_id}=req.body;
        //根据当前的id信息查找信息
        proCenterModel.findById(_id,async (error,doc)=>{
            if(error){//如果返回错误信息则跳转至前一页
                res.redirect('back');
            }else{//否则保存修改后的信息，存至数据库
                doc.centername=centername;
                await doc.save();
                res.redirect('/admin/product/proCenter/list');
            }
        })
    };

    //1.4添加
    //
    static getProCenterAdd=(req,res)=>{
        res.render('proCenter-add',{title:'产品分类的添加',info:{}});
    };
    //
    static getProCenterStore=async (req,res)=>{
        //1.收集数据->定义表的模型->入库
        //1.1接收数据
        let {centername}=req.body;
        console.log(centername);
        //1.2将数据实例化
        let proCenterObj=new proCenterModel({centername});
        //1.3验证表单信息是否合法
        let error=proCenterObj.validateSync();
        //1.3.1对验证信息进行处理
        if(error){
            //得到错误信息
            const errorRs=[];
            for(let attr in error.errors){
                errorRs.push(`${proCenterModel.fields[attr]},${error.errors[attr]}`);
            }
            //将错误信息返回给前台
            let url='/admin/product/proCenter/add';
            let time=3;

            res.render('error',{errorRs,url,time});
            return;
        }
        //1.3.2信息合法
        try{
            let  info=await proCenterObj.save();
            //跳转至产品详情信息展示
            res.redirect('/admin/product/proCenter/list');
        }catch (e) {
            //跳转至增加页面
            res.redirect('/admin/product/proCenter/add');
        }
    };



    //2.“产品详情”页面的curd
    //2.1添加
    //
    static getProDetailAdd=async (req,res)=>{
        const proCenterInfo=await proCenterModel.find();
        // res.json(proCenterInfo);
        res.render('proDetail-add',{title:'产品详情的添加',info:{},proCenterInfo});
    };
    //表单提交
    static getProDetailStore=async (req,res)=>{
        //1.收集数据->定义表的模型->入库
        //1.1接收数据
        let {title,popular,description,sortId}=req.body;
        let pic='';
        if(req.file){
            pic=req.file.filename;
        }
        //1.2将数据实例化
        let proDetailObj=new proDetailModel({title,popular,description,pic,sortId});
        //1.3验证表单信息是否合法
        let error=proDetailObj.validateSync();
        //1.3.1对验证信息进行处理
        if(error){
            //得到错误信息
            const errorRs=[];
            for(let attr in error.errors){
                errorRs.push(`${proDetailModel.fields[attr]},${error.errors[attr]}`);
            }
            //将错误信息返回给前台
            let url='/admin/product/proDetail/add';
            let time=3;

            res.render('error',{errorRs,url,time});
            return;
        }
        //1.3.2信息合法
        try{
            let  info=await proDetailObj.save();
            //跳转至产品详情信息展示
            res.redirect('/admin/product/proDetail/list');
        }catch (e) {
            //跳转至增加页面
            res.redirect('/admin/product/proDetail/add');
        }
    };

    //2.2展示
    //后台
    static getProDetailList=async(req,res)=>{
        let {page=1,size=2}=req.query;
            page=parseInt(page);
            size=parseInt(size);
            //获取总数
        // let count= await proDetailModel.count();
        let count= await proDetailModel.countDocuments();

        //获取偏移量
        let offset=(page-1)*size;
        //获取总共的页数
        let totalPage=Math.ceil(count/size);
        //得到新闻分类的内容
        const infos=await proDetailModel.aggregate([
            {
                $skip:offset
            },
            {
                $limit:size
            },
            {
                $lookup:{
                    //要关联的表procenter
                    from:'procenter',
                    //自己表里和其他表产生关系的属性
                    localField:'sortId',
                    //关联表的id
                    foreignField:'_id',
                    //查询到的关联信息
                    as:'centerInfo',
                }
            }
        ]);
        res.render('proDetail-list',{page,size,count,totalPage,title:'产品详情的展示',infos,moment});
    };


    //2.3编辑
    //
    static getProDetailEdit=async (req,res)=>{
        //得到id
        let detailId=req.params.id;
        //通过id进行查找
        let info=await proDetailModel.findOne({_id:detailId});
        const detailInfo=await proCenterModel.find();
        res.render('proDetail-edit',{title:'产品详情的编辑',info,detailInfo});
    };
    //更新
    static getProDetailEditStore=async (req,res)=>{
        let {_id,title,popular,description,sortId}=req.body;
        let pic='';
        if(req.file){
            pic=req.file.filename;
        }
        //根据当前的id信息查找信息
        proDetailModel.findById(_id,async (error,doc)=>{
            if(error){//如果返回错误信息则跳转至前一页
                res.render('error');
            }else{//否则保存修改后的信息，存至数据库
                doc.title=title;
                doc.popular=popular;
                doc.description=description;
                doc.sortId=sortId;
                if(pic){
                    doc.pic=pic;
                }
                await doc.save();
                res.redirect('/admin/product/proDetail/list');
            }
        })
    };

    //2.4删除
    static getProDetailDelete=async (req,res)=>{
        let detailId=req.params.id;
        try{
            await proDetailModel.deleteOne({_id:detailId});
            //back返回上一级页面
            res.redirect('back');
        }catch (e) {
            //back返回上一级页面
            res.redirect('back');
        }
    };



    //二.前台
    //1.通过不同的类别展示不同的内容
    static getProDetailFrontList=async(req,res)=>{

        let {page=1,size=8}=req.query;
        page=parseInt(page);
        size=parseInt(size);
        //获取总数
        // let count= await proDetailModel.count();
        let count= await proDetailModel.countDocuments();
        //获取偏移量
        let offset=(page-1)*size;
        //获取总共的页数
        let totalPage=Math.ceil(count/size);

        //1.得到产品分类信息
        const proCenterInfo=await proCenterModel.find();


        //2.动态获取分类值
        //2.1默认值为塑胶料
        let pla='612b6067fa77ea124858098d';
        let che='612b6073fa77ea1248580991';

        //2.2动态获取
        let sortId=req.query.sortId ? req.query.sortId : '';

        // console.log("proCenterInfo", proCenterInfo);
        let flag=false;
        for(let i=0 ;i<proCenterInfo.length;i++){
            // console.log(proCenterInfo[i]);
            if(proCenterInfo[i]._id==sortId){
                flag=true;
                // console.log(proCenterInfo[i].centername);
                if(proCenterInfo[i].centername=='化工类'){
                    const infos=await proDetailModel.find({sortId});
                    res.render('front/index2',{page,size,count,totalPage,title:"化工类产品列表页",proCenterInfo,infos,moment});
                }else if(proCenterInfo[i].centername=='塑胶类'){
                    //3.根据值找内容
                    const infos=await proDetailModel.find({sortId});
                     res.render('front/index12',{title:"塑胶料产品列表页",proCenterInfo,infos,sortId});
                }else{
                    const infos=await proDetailModel.find({sortId});
                    res.render('front/index12',{title:proCenterInfo[i].centername,proCenterInfo,infos,sortId});
                }
            }
        }
        if(flag==false){
            {
                const infos=await proDetailModel.aggregate([
                    {
                        $skip:offset
                    },
                    {
                        $limit:size
                    },
                    {
                        $lookup:{
                            //要关联的表procenter
                            from:'procenter',
                            //自己表里和其他表产生关系的属性
                            localField:'sortId',
                            //关联表的id
                            foreignField:'_id',
                            //查询到的关联信息
                            as:'centerInfo',
                        }
                    }
                ]);


                res.render('front/index12',{page,size,count,totalPage,title:"产品列表页",proCenterInfo,infos,sortId});
            }
        }
        // if(sortId==pla){
        //     //3.根据值找内容
        //     const infos=await proDetailModel.find({sortId});
        //     res.render('front/index12',{title:"塑胶料产品列表页",proCenterInfo,infos,sortId});
        // }else if(sortId==che){
        //     const infos=await proDetailModel.find({sortId});
        //     res.render('front/index2',{page,size,count,totalPage,title:"化工类产品列表页",proCenterInfo,infos,moment});
        // }else{
        //     //得到新闻分类的内容
        //     const infos=await proDetailModel.aggregate([
        //         {
        //             $skip:offset
        //         },
        //         {
        //             $limit:size
        //         },
        //         {
        //             $lookup:{
        //                 //要关联的表procenter
        //                 from:'procenter',
        //                 //自己表里和其他表产生关系的属性
        //                 localField:'sortId',
        //                 //关联表的id
        //                 foreignField:'_id',
        //                 //查询到的关联信息
        //                 as:'centerInfo',
        //             }
        //         }
        //     ]);
        //
        //
        //     res.render('front/index12',{page,size,count,totalPage,title:"产品列表页",proCenterInfo,infos,sortId});
        // }
    };


    //2.产品详情页面的展示
    static getProFrontList=async(req,res)=>{

        //1.得到产品分类信息
        const proCenterInfo=await proCenterModel.find();
        // console.log(proCenterInfo);

        //2.得到鼠标点击的分类信息
        let sortId=req.query.sortId ? req.query.sortId : '';
        //3.得到鼠标点击具体产品
        let _id=req.query._id ? req.query._id : '';
        //4.根据点击的内容更改人气值
        proDetailModel.findOne({_id:_id},async (error,doc)=>{
            if(error){//如果返回错误信息则跳转至前一页
                res.redirect('back');
            }else{//否则保存修改后的信息，存至数据库
                doc.popular+=1;
                await doc.save();
                res.render('front/view-48',{title:"产品详情页",info:doc,_id,moment,sortId,proCenterInfo});
            }
        });
    };
}

//暴露
module.exports=ProDetailControllers;